// import { request } from 'xy-utils'
import request from '../../http/http';
// 是否开发环境
const devEnv = process.env.NODE_ENV === 'development'// yuxp配置应用集成代理前缀

export const YUXP_CONFIGER_APP_PRE = "/yuxp-web"// 页面映射存储

const PAGE_MAPPING_KEY = 'PAGE-MAPPING'

/**
 * 通过require上下文获取PageMapping
 * *注:由听文件变化禁用，故此方法获取到的数据是启动服务时的数据
 */
const getPageMappingByRequire = () => {
  //获取匹配指定模式的上下文
  const context = require.context('@/views/xpVue', true, /\/pagePath\.json$/)
  //初始化合并后的数据对象
  const mergedData = {};
  // 遍历匹配的模块并合并到对象中
  context.keys().forEach(modulePath => {
    // 获取模块的相对路径
    const relativeModulePath = modulePath.replace('./', '')
    try {
      // 使用require导入模块
      const jsonData = require(`@/views/xpVue/${relativeModulePath}`)
      Object.assign(mergedData, jsonData)
    }
    catch (error) {
      // 处理读取或解析错误
      console.error(`无法读取或解析 ${modulePath}: ${error.message}`)
    }
  })
  return mergedData
}

/**
 * 获取最新 PageMapping 数据，并存储于浏览器存储中
 */
export const getPageMappingByRequest = () => {
  request({
    url: '/yuxp-previewer/fetch/pagepath',
    method: 'get'
  }).then(res => {
    const { code, data } = res
    if (code == 0) {
      //将最新的page-mapping数据存储于浏览器
      window.sessionStorage.setItem(PAGE_MAPPING_KEY, JSON.stringify(data))
    }
  })
}

//是否首次加载pageMapping
let isFirstLoadPageMapping = true


/**
 * 获取映射文件
 * @returns 
 */
export function getPageMapping() {
  // 缓存起来，避免每次都去读写，另外单个文件预览生成时，也不用再次去加载
  let retPageMapping = {}
  //1.若浏览器会话存储中有pageMapping，并且能正确解析，则直接返回
  const pageMapping = window.sessionStorage.getItem(PAGE_MAPPING_KEY)
  if (pageMapping) {
    try {
      return JSON.parse(pageMapping)
    } catch (ex) {
      // 获取存储的pageMapping解析错误，则忽略错误，直接重新获取
    }
  }
  console.warn('[YuxpPreviewer]调用`getPageMapping 时，在浏览器存储中没有获取到值，因此拿到的数据有可能不全。')
  //2.若浏览器会话存储中无pageMapping，则先直接通过require获取，避免走异步加载
  retPageMapping = getPageMappingByRequire()
  //但是上一步骤获取的数据极其可能不是最新的(开发环境)，因为服务启动后生成的页面路径不会热更新加载
  //避免此情况，最好是在业务工程加载首页时，注册调用一下 getPageMappingByRequest
  //然后再将最新pageMapping请求下来存储好，下次访问时则直接获取最新的pagePath
  //开发环境才去通过NODE API获取最新pageMapping
  if (isFirstLoadPageMapping && devEnv) {
    isFirstLoadPageMapping = false
    getPageMappingByRequest()
  }
  return retPageMapping
}

/**
 * 根据映射文件加载vue页面，如果页面不存在，打开404页面
 * @param {*} pageId 
 * @param {*} pageNodeId 
 * @returns 
 */
export function loadPageByMapping(pageId, pageNodeId) {
  return new Promise((resolve) => {
    let errorMessage = '';
    if (!pageId) {
      errorMessage = `参数页面编码:${pageId}不存在!`
    }
    const mapping = getPageMapping()
    // 同时兼容两种pagePath存储结构:
    //1.`{pagecode:{ path:'yourPagePath', md5: 'yourPageMd5'}}
    // 2.{ pagecode: yourPagePath }
    const pagePath = typeof mapping[pageId] === 'object' ? mapping[pageId].path : mapping[pageId]
    if (!pagePath) {
      errorMessage = `页面编码【${pageId}】在views/xpVue/*/pagePath.json文件中没有匹配到路径`
    }
    if (errorMessage) {
      resolve(loadNotFound(`[PageFactory]加载错误:${errorMessage}`))
    }
    else {
      const filepath = `@/views/${pagePath}`
      if (!devEnv) {
        let cmp = null
        try {
          cmp = require('@/views/' + pagePath).default
        } catch (error) {
          cmp = loadNotFound(`[PageFactory]加载错误:${pagePath}`)
        }
        resolve(cmp)
      } else {
        request({
          url: `/yuxp-previewer/fetch/code?filepath=${filepath}`,
          method: 'get'
        }).then(res => {
          const { code, data } = res
          let previewerComponent
          if (code == 0) {
            previewerComponent = {
              functional: false,
              render(h) {
                //标识页面工厂使用YuxpPreviewer渲染
                this.isYuxpPreviewer = true
                const attrs = this.$attrs
                // 使用 h 函数创建组件的虚拟 DOM
                return h('yuxp-preview-component', {
                  attrs: {
                    code: data,
                    cmpAttrs: attrs
                  }
                })
              }
            }
          } else {
            previewerComponent = loadNotFound(`[PageFactory]加载错误:${filepath}`)
          }
          resolve(previewerComponent)
        }).catch(() => {
          resolve(loadNotFound(`[PageFactory]加载错误: ${filepath} `))
        })
      }
    }
  })
}

/**
 * 
 * @param {*} errorMessage 
 * @returns 
 */
export function loadNotFound(errorMessage) {
  const img = require('./404.png')
  return {
    functional: false,
    render(h) {
      return h('div', { class: 'yuxp404 wscn-http404-container' }, [
        h('div', { class: 'wscn-http44' }, [
          h('div', { class: 'pic-404' }, [
            h('img', {
              class: 'pic-404 parent', src: img, alt: '404'
            })
          ]),
          h('div', { class: 'bullshit' }, [
            h('div', { class: 'bullshit oops' }, errorMessage)
          ])
        ])
      ])
    },
  }
}